//package com.zg.common.core.service.support;
//
//import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
//import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
//import com.zg.common.core.dao.LikePattern;
//import com.zg.common.core.dao.QueryCondition;
//import org.springframework.util.ReflectionUtils;
//import java.lang.reflect.Field;
//import java.lang.reflect.Method;
//import java.util.*;
//import java.util.concurrent.ConcurrentHashMap;
//
///**
// * 查询条件构建工具（简化版）
// */
//public class QueryWrapperBuilder {
//
//    // 缓存：实体类 -> 字段名 -> Lambda方法引用
//    private static final Map<Class<?>, Map<String, SFunction<?, ?>>> LAMBDA_CACHE = new ConcurrentHashMap<>();
//
//    /**
//     * 构建查询条件（自动推断实体类字段）
//     */
//    public static <T> LambdaQueryWrapper<T> build(Object queryParam, Class<T> entityClass) {
//        LambdaQueryWrapper<T> wrapper = new LambdaQueryWrapper<>();
//        if (queryParam == null) return wrapper;
//
//        Class<?> paramClass = queryParam.getClass();
//        for (Field field : paramClass.getDeclaredFields()) {
//            field.setAccessible(true);
//            QueryCondition condition = field.getAnnotation(QueryCondition.class);
//            if (condition == null) continue;
//
//            try {
//                Object value = field.get(queryParam);
//                if (value == null) continue; // 跳过空值
//
//                // 获取实体类字段名
//                String entityFieldName = getEntityFieldName(field, condition);
//
//                // 获取原始SFunction（通配符类型）
//                SFunction<?, ?> rawFunction = getRawColumnFunction(entityClass, entityFieldName);
//
//                // 转换为具体泛型的SFunction
//                SFunction<T, Object> column = GenericUtils.castSFunction(
//                        rawFunction, entityClass, Object.class
//                );
//
//                // 添加查询条件
//                addCondition(wrapper, column, value, condition);
//            } catch (Exception e) {
//                throw new RuntimeException("构建查询条件失败: " + field.getName(), e);
//            }
//        }
//        return wrapper;
//    }
//
//    /**
//     * 获取原始SFunction（通配符类型）
//     */
//    private static <T> SFunction<?, ?> getRawColumnFunction(Class<T> entityClass, String fieldName) {
//        Map<String, SFunction<?, ?>> methodMap = LAMBDA_CACHE.computeIfAbsent(
//                entityClass, k -> new ConcurrentHashMap<>()
//        );
//
//        return methodMap.computeIfAbsent(fieldName, k -> {
//            try {
//                String getterName = "get" +
//                        fieldName.substring(0, 1).toUpperCase() +
//                        fieldName.substring(1);
//
//                Method getterMethod = entityClass.getMethod(getterName);
//                Class<?> returnType = getterMethod.getReturnType();
//
//                // 使用Lambda表达式实现SFunction
//                return (SFunction<T, Object>) (t -> {
//                    try {
//                        return getterMethod.invoke(t);
//                    } catch (Exception e) {
//                        throw new RuntimeException(e);
//                    }
//                });
//            } catch (Exception e) {
//                throw new RuntimeException("生成SFunction失败: " + fieldName, e);
//            }
//        });
//    }
//
//
//    /**
//     * 获取实体类字段名
//     */
//    private static String getEntityFieldName(Field paramField, QueryCondition condition) {
//        return condition.fieldName().isEmpty() ? paramField.getName() : condition.fieldName();
//    }
//
//    /**
//     * 根据条件类型添加查询条件
//     */
//    private static <T> void addCondition(LambdaQueryWrapper<T> wrapper,
//                                         SFunction<T, ?> column,
//                                         Object value,
//                                         QueryCondition condition) {
//        switch (condition.type()) {
//            case EQ:
//                wrapper.eq(column, value);
//                break;
//            case LIKE:
//                String likeValue = buildLikeValue(value.toString(), condition.likePattern());
//                wrapper.like(column, likeValue);
//                break;
//            case IN:
//                if (value instanceof Collection) {
//                    wrapper.in(column, (Collection<?>) value);
//                } else if (value.getClass().isArray()) {
//                    wrapper.in(column, (Object[]) value);
//                }
//                break;
//            case BETWEEN:
//                if (value instanceof List && ((List<?>) value).size() == 2) {
//                    List<?> list = (List<?>) value;
//                    wrapper.between(column, list.get(0), list.get(1));
//                }
//                break;
//            case GT:
//                wrapper.gt(column, value);
//                break;
//            case LT:
//                wrapper.lt(column, value);
//                break;
//            case IS_NULL:
//                wrapper.isNull(column);
//                break;
//            // 其他条件类型...
//        }
//    }
//
//    /**
//     * 构建模糊查询值
//     */
//    private static String buildLikeValue(String value, LikePattern pattern) {
//        switch (pattern) {
//            case LEFT:
//                return "%" + value;
//            case RIGHT:
//                return value + "%";
//            case ALL:
//                return "%" + value + "%";
//            default:
//                // 根据实际需求处理默认情况，这里简单抛出异常或返回默认值
//                throw new IllegalArgumentException("Unsupported LikePattern: " + pattern);
//        }
//    }
//}